#include "string.h"
#include "ring_buffer.h"



/* log输出 */
//#define DBG_ENABLE
//#define DBG_SECTION_NAME "ring_buffer"
//#define DBG_LEVEL DBG_LOG
//#define DBG_COLOR
//#include "rtdbg.h"

/****************************************************************************
@ZiBuYu :2017-10-12  
@brief ：字符串比较函数
@note  ：判断有点多，最好分缓存区比较，这样好呀
@param : None
@retval：None.
****************************************************************************/
char*string_equal_compare( struct ring_buffer_def*buf, u16 start_addr, const char*str )
{
	char *ret_data =0 ;
	u16   cnt = 0;
	
	if( start_addr>=buf->parent.size )
	{
		start_addr = start_addr%buf->parent.size;
	}			
	while( start_addr != buf->parent.get_idx )
	{
		if( str[ cnt ]!=NULL )	
		{
			if( str[ cnt ] == buf->dat[ start_addr ] )
			{
				if( cnt == 0 )
				{
					ret_data = ( char* )&buf->dat[ start_addr ];
				}
				cnt++;
			}
			else 
			{
				ret_data = 0 ;
				if ( cnt > 0 )
				{
					cnt = 0;
					continue;
				}
			}
		}
		else 
		{
			break;
		}	
		if( ++start_addr>=buf->parent.size )
		{
			start_addr = 0;
		}	
	}	
	if( str[ cnt ] != NULL )
	{
		ret_data = 0 ;
	}
	return ret_data; 
}

/****************************************************************************
@ZiBuYu :2017-10-12  
@brief ：从环形缓存区中取数
@param : None
@retval：None.
****************************************************************************/
void ring_buffer_get_data( u8*obj, u16 start_addr, u16 len, struct ring_buffer_def*buf )
{
	u16 i;
	u16 lus_num;
	
	if( start_addr >= buf->parent.size )
	{
		start_addr %= buf->parent.size;
	}
	lus_num = buf->parent.size - start_addr;
	if( lus_num >= len )			
	{
		for( i=0; i<len; i++ )		
		{
			obj[ i ] = buf->dat[ start_addr++ ];
		}
	}
	else							
	{
		for( i=0; i< lus_num; i++ )	
		{
			obj[ i ] = buf->dat[ start_addr++ ];
		}
		start_addr = 0;
		for( i=lus_num; i< len ; i++ )
		{
			obj[ i ] = buf->dat[ start_addr++ ];
		}
	}
}
/****************************************************************************
@ZiBuYu :2022-12-27  
@brief ：从环形缓存区中取数
@param : None
@retval：None.
****************************************************************************/
void get_data_from_ring_buffer( struct ring_buffer_def*buf, u8*obj, u16 len )
{
	ring_buffer_read_block( buf, obj, len );
}
/****************************************************************************
@ZiBuYu：2019-05-26  
@brief ：缓存区中添加数据块
@param ：None
@retval：None
****************************************************************************/ 
void cpy_data_to_ring_buffer( struct ring_buffer_def*buf, u8*dat, u16 num )
{
	ring_buffer_write_block( buf, dat, num );
}
/****************************************************************************
@ZiBuYu：2017-10-12  
@brief ：获取缓存剩余空间
@param ：None
@retval：None
****************************************************************************/
s16 get_free_ring_buffer( struct buf_pubilc_def *index )
{
	s16 len;
	
	if ( index->is_full == true )
	{
		len = index->size;
	}
	else
	{
		len = index->get_idx - index->put_idx;
		if ( len < 0 )
		{
			len+=index->size;
		}	
	}
	len = index->size - len ;
	return len;
}
/****************************************************************************
@ZiBuYu：2020-10-12  
@brief ：判断缓存区是否为空 不考虑套圈
@param ：None
@retval：None
****************************************************************************/
s16 get_empty_ring_buffer( struct buf_pubilc_def *index )
{
	if ( index->is_full == true )
	{
		return -1;
	}
	s16 len = index->get_idx - index->put_idx;
	if ( len < 0 )
	{
		len+=index->size;
	}
	return len;
}
/****************************************************************************
@ZiBuYu：2020-10-12  
@brief ：获取缓存数据量 不考虑套圈
@param ：None
@retval：None
****************************************************************************/
s16 get_hold_ring_buffer( struct buf_pubilc_def *index )
{
	s16 len;
	
	if ( index->is_full == true )
	{
		len = index->size;
	}
	else
	{
		len = index->get_idx - index->put_idx;
		if ( len < 0 )
		{
			len+=index->size;
		}	
	}
	return len;
}
/****************************************************************************
@ZiBuYu：2017-10-12  
@brief ：空函数
@param ：None
@retval：None
****************************************************************************/
void null_task(void)
{
	
}

/* 2023 增加新接口 */
/****************************************************************************
@ZiBuYu：2023-02-26  
@brief ：缓存区清零
@param ：None
@retval：None
****************************************************************************/
void ring_buffer_clear( struct buf_pubilc_def *obj )
{
	obj->put_idx = 0 ;
	obj->get_idx = 0 ;
	obj->is_full = false ;
}
/****************************************************************************
@ZiBuYu：2023-02-26  
@brief ：获取缓存数据量 不考虑套圈
@param ：None
@retval：None
****************************************************************************/
u16 ring_buffer_get_use_length( struct buf_pubilc_def *obj )
{
	if ( obj->is_full == true )
	{
		return obj->size;
	}
	s16 len = obj->get_idx - obj->put_idx;
	if ( len < 0 )
	{
		len+=obj->size;
	}
	return len;	
}
u16 ring_buffer_get_surplus_length( struct buf_pubilc_def *obj )
{
	return (obj->size - ring_buffer_get_use_length( obj ));
}
void ring_buffer_write_block( struct ring_buffer_def*buf, u8*dat, u16 num )
{
	u32 len,i;
	u16 idx = buf->parent.get_idx ;
    len = buf->parent.size - idx;
    if ( len >= num)
    {
        for ( i = 0; i < num; i++)
        {
            buf->dat[idx++] = dat[i];
        }
    }
    else
    {
        for ( i = 0; i < len; i++)
        {
            buf->dat[idx++] = dat[i];
        }
        idx = 0 ;
        for ( ; i < num; i++)
        {
            buf->dat[idx++] = dat[i];
        }
    }
	if ( idx >= buf->parent.size )
	{
		idx = 0 ;
	}	
	buf->parent.get_idx = idx ;
}
void ring_buffer_read_block( struct ring_buffer_def*buf, u8*dat, u16 num )
{
	u16 i;
	u16 len;
	u16 idx = buf->parent.put_idx ;
	len = buf->parent.size - buf->parent.put_idx;
	if( len > num )			
	{
		for( i=0; i<num; i++ )		
		{
			dat[ i ] = buf->dat[ idx++ ];
		}
	}
	else							
	{
		for( i=0; i< len; i++ )	
		{
			dat[ i ] = buf->dat[ idx++ ];
		}
		idx = 0;
		for( ; i< num ; i++ )
		{
			dat[ i ] = buf->dat[ idx++ ];
		}
	}
	if ( idx >= buf->parent.size )
	{
		idx = 0 ;
	}	
	buf->parent.put_idx = idx ;
}




